/**
 * 管理器基类
 * 职责：
 * 1. 提供统一的生命周期管理
 * 2. 统一的错误处理
 * 3. 统一的日志记录
 * 4. 依赖注入支持
 */
export abstract class BaseManager {
    protected name: string;
    protected isInitialized: boolean = false;
    protected dependencies: string[] = [];

    constructor() {
        this.name = this.constructor.name;
    }

    /**
     * 获取管理器名称
     */
    getName(): string {
        return this.name;
    }

    /**
     * 获取依赖列表
     */
    getDependencies(): string[] {
        return this.dependencies;
    }

    /**
     * 检查是否已初始化
     */
    isReady(): boolean {
        return this.isInitialized;
    }

    /**
     * 初始化管理器
     * 子类必须实现此方法
     */
    abstract init(): Promise<void> | void;

    /**
     * 保存数据
     * 子类可选实现
     */
    save?(): Promise<void> | void;

    /**
     * 销毁管理器
     * 子类可选实现
     */
    destroy?(): Promise<void> | void;

    /**
     * 记录日志
     */
    protected log(level: 'info' | 'warn' | 'error', message: string, data?: any) {
        const prefix = `[${this.name}]`;
        switch (level) {
            case 'info':
                console.log(prefix, message, data || '');
                break;
            case 'warn':
                console.warn(prefix, message, data || '');
                break;
            case 'error':
                console.error(prefix, message, data || '');
                break;
        }
    }

    /**
     * 统一的错误处理
     */
    protected handleError(error: any, operation: string): void {
        const errorMessage = `${operation}失败: ${error.message || error}`;
        this.log('error', errorMessage, error);
        
        // 在开发环境下抛出错误，生产环境下只记录
        if (process.env.NODE_ENV === 'development') {
            throw error;
        }
    }

    /**
     * 异步操作包装器，提供统一的错误处理
     */
    protected async safeExecute<T>(
        operation: () => Promise<T>, 
        operationName: string
    ): Promise<T | null> {
        try {
            const result = await operation();
            this.log('info', `${operationName}成功`);
            return result;
        } catch (error) {
            this.handleError(error, operationName);
            return null;
        }
    }

    /**
     * 标记为已初始化
     */
    protected markAsInitialized(): void {
        this.isInitialized = true;
        this.log('info', '初始化完成');
    }

    /**
     * 验证依赖
     */
    protected validateDependencies(availableManagers: Set<string>): boolean {
        const missingDeps = this.dependencies.filter(dep => !availableManagers.has(dep));
        if (missingDeps.length > 0) {
            this.log('error', `缺少依赖: ${missingDeps.join(', ')}`);
            return false;
        }
        return true;
    }
}

/**
 * 管理器注册表
 * 负责管理器的注册、依赖解析和初始化顺序
 */
export class ManagerRegistry {
    private managers = new Map<string, BaseManager>();
    private initOrder: string[] = [];

    /**
     * 注册管理器
     */
    register(manager: BaseManager): void {
        const name = manager.getName();
        if (this.managers.has(name)) {
            console.warn(`管理器 ${name} 已存在，将被覆盖`);
        }
        this.managers.set(name, manager);
    }

    /**
     * 获取管理器
     */
    get<T extends BaseManager>(name: string): T | undefined {
        return this.managers.get(name) as T;
    }

    /**
     * 解析依赖顺序
     */
    private resolveDependencies(): string[] {
        const visited = new Set<string>();
        const visiting = new Set<string>();
        const order: string[] = [];

        const visit = (name: string) => {
            if (visited.has(name)) return;
            if (visiting.has(name)) {
                throw new Error(`检测到循环依赖: ${name}`);
            }

            visiting.add(name);
            const manager = this.managers.get(name);
            if (manager) {
                for (const dep of manager.getDependencies()) {
                    if (this.managers.has(dep)) {
                        visit(dep);
                    } else {
                        console.warn(`管理器 ${name} 的依赖 ${dep} 不存在`);
                    }
                }
            }
            visiting.delete(name);
            visited.add(name);
            order.push(name);
        };

        for (const name of this.managers.keys()) {
            visit(name);
        }

        return order;
    }

    /**
     * 按依赖顺序初始化所有管理器
     */
    async initializeAll(): Promise<void> {
        console.log('🚀 开始初始化管理器...');
        
        try {
            this.initOrder = this.resolveDependencies();
            console.log('📋 初始化顺序:', this.initOrder);

            const availableManagers = new Set(this.managers.keys());

            for (const name of this.initOrder) {
                const manager = this.managers.get(name);
                if (manager && !manager.isReady()) {
                    // 验证依赖
                    if ((manager as any).validateDependencies(availableManagers)) {
                        console.log(`🔧 初始化管理器: ${name}`);
                        await manager.init();
                    } else {
                        console.error(`❌ 管理器 ${name} 依赖验证失败`);
                    }
                }
            }

            console.log('✅ 所有管理器初始化完成');
        } catch (error) {
            console.error('❌ 管理器初始化失败:', error);
            throw error;
        }
    }

    /**
     * 保存所有管理器数据
     */
    async saveAll(): Promise<void> {
        console.log('💾 开始保存管理器数据...');
        
        for (const name of this.initOrder.reverse()) { // 逆序保存
            const manager = this.managers.get(name);
            if (manager && manager.save) {
                try {
                    await manager.save();
                    console.log(`✅ ${name} 数据保存完成`);
                } catch (error) {
                    console.error(`❌ ${name} 数据保存失败:`, error);
                }
            }
        }
    }

    /**
     * 销毁所有管理器
     */
    async destroyAll(): Promise<void> {
        console.log('🔥 开始销毁管理器...');
        
        for (const name of this.initOrder.reverse()) { // 逆序销毁
            const manager = this.managers.get(name);
            if (manager && manager.destroy) {
                try {
                    await manager.destroy();
                    console.log(`✅ ${name} 销毁完成`);
                } catch (error) {
                    console.error(`❌ ${name} 销毁失败:`, error);
                }
            }
        }
    }

    /**
     * 获取所有管理器状态
     */
    getStatus(): { [key: string]: boolean } {
        const status: { [key: string]: boolean } = {};
        for (const [name, manager] of this.managers) {
            status[name] = manager.isReady();
        }
        return status;
    }
}

// 全局管理器注册表
export const managerRegistry = new ManagerRegistry();
